Code
import pint
ureg = pint.UnitRegistry()
import numpy as np
from tabulate import tabulate
import matplotlib.pyplot as pltLast update: 25 Nov 2023
Last update: 28 Nov 2023
This page is a test post. The Jupyter notebook is a rough draft. So far I like how Quarto renders JupyterLab notebooks to HTML. This post is for testing only. Grammar and spelling checks have not been done.
This notebook examines the design of a small hydroelectric water wheel built by Kris Harbour Natural Building. The water wheel is a 2.1 meter diameter wheel and he expected to generate between 1.5 and 1.7 kW. The project is documented in four YouTube videos, links are here: Part 1, Part 2, Part 3 and Part 4. The videos provide some technical details, but not enough to satisfy me. My JupyterLab notebook will cover the project description, the water wheel design, generator, flume, inverter and other topics he did not address such as instrumentation, safety, maintenance, reliability and economics.
This notebook will review a few technical aspects of the project. I’ll try not to be too much of an armchair quarterback, or provide minute by minute commentary, since Kris does a good job of stating his frustrations as he narrates his videos. Over all, this is a very interesting project. The craftmanship and construction of the water wheel is very good. I think most of the issues are with other aspects of the project.
The important technical aspects for the water wheel, gear box and generator have been summarized in the table below:
| Parameter | Value | Notes |
|---|---|---|
| Wheel diameter | 2.1 meters | Part 1 @ 0:35 |
| Wheel width | 0.8 meters | same as flume |
| Bucket volume | 48 liters | Part 1 @ 27:10 |
| Number of Buckets | 16 | Part 1 @ 19:50 |
| Flume length | 8 meters | project survey document |
| Flume drop | 0.3 meters | project survey document |
| Flume width | 0.8 meters | project survey document |
| Flow rate | 70 to 120 liters/sec | project survey document |
| Gear box | 1:20 + 1:2 belt | total 1:40 |
| Induction generator | 2.2kw, 8 pole, 750 rpm | final video |
In part 4 of his video, Kris shared some details of his orginal project survey. I captured images from the video and used google docs to convert the shreenshots to text. This document, converted to a pdf, can be viewed here: project survey dated 16/02/23
Each of the videos is about 40 minutes long. While watching, I took notes whenever he gave any technical details. The videos primarily document the build, installationa and some of the testing of the water wheel. The construction of the dam and flume were performed by others. Most of the testing he did on site after installation. The exception was some open circuit testing of the first generator in his workshop, which at the time, he thought was adequate.
Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 1
Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 2
Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 3
Why did he change to a lower voltage alternater? Old alternater was making 420 volts, he wanted 220 volts.
Powering An Old Mill 1.5 Kw Lake District Overshot Waterwheel Project Part 4
In the calculations that follow, I’m using the Python package, Pint, which allows mathematical operations with units and conversions to and from different units. Keeping track of the units will provide some error checking when performing the calculations. I’ll be using metric units since these are what Kris has been using. All calculations are done using the International System of units. A list of units and conversions used by Pint is here.
There are a couple of variables and constants that will be used throughout the calculations.
I’ll be using descriptive names for the variable used in my calculations.
Kris uses the term ‘trough’ for the structure that carries the water to the top of the water wheel; I’ll be using the term Flume to describe the structure.
Other terms are:
The harvesting of the gravitational energy of water is a proven source of energy. Since a waterwheel is used to extract power from the water, the head height is approximately the diameter of the waterwheel. Water enters at the top of the wheel and the weight of the water causes the wheel to rotate until a point near the bottom of the wheel. So let’s use the diameter of the waterwheel.
The gravitational power of water is given by:
\(P = \rho \times g \times Q \times H\)
where:
P = gravitational power of water
H = height of fall Q = flow rate
g = acceleration due to gravity
\(\rho\) = density of water
Kris provided his customer an estimated of the power that might be generated versus flow rates. The following table is from his project survey. Kris used H = 2.6 meters and \(\eta\) of 0.6.
| Flow rate | Power, Watts |
|---|---|
| 60 lps | 833 |
| 70 lps | 1,030 |
| 80 lps | 1,177 |
| 90 lps | 1,324 |
| 100 lps | 1,472 |
| 110 lps | 1,619 |
| 116 lps | 1,692 |
My power calculations are shown below.
H = 2.6ureg.meter eta = 0.6 Q = np.array([60,70,80,90,100,110,116])ureg.liter/(1ureg.sec) print(‘head height: {:.1fP}, 3B7: {:.1f}’.format(H,eta)) print(‘{:<15s}{:<10s}’.format(‘Flow rate’, ‘power’)) for i in Q: print(‘{:<3.0f~P} {:<,.1f~P}’.format(i.to(‘l/s’),(rhogiH*eta).to(‘watts’)))
H = 2.6*ureg.meter
eta = 0.6
Q = np.array([60,70,80,90,100,110,116])*ureg.liter/(1*ureg.sec)
print('head height: {:.1fP}, \u03B7: {:.1f}'.format(H,eta))
table_header = ['Flow rate, lps', 'power, W']
table_row = []
for i in Q:
table_row.append([i.to('l/s').magnitude,(rho*g*i*H*eta).to('watts').magnitude])
print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f')))head height: 2.6 meter, η: 0.6
Flow rate, lps power, W
---------------- ----------
60 917.7
70 1,070.6
80 1,223.6
90 1,376.5
100 1,529.5
110 1,682.4
116 1,774.2
My numbers don’t match Kris’s numbers, which he presented in his project survey. Also, seems courious that the final number in his table is 116 lps and not 120 lps.
The history of water wheels dates back thousands of years and the fundementals of water wheels are well understood. What is new is the restoration of historic water mills being employed to generate electricity. Water wheels have a low rotational speed with high torque and this equires the use of gears to step up the rotational speed to a level that can be used by electrical generators. I found two intreseting examples of small water wheels being used to generate electrical power. In each of these examples, we can calculate the overall efficiency. This is a useful data point since these water wheels are of simular size to the one Kris built.
Eskdale Mill
The Eskdale Mill is profiled in the YouTube video (link above). Smith Engineering performed the design of the water wheel. The wheel is installed at the oldest and last working corn mill in the English Lake District, providing power for the miller’s cottage. It has been positioned adjacent to the Grade II* listed mill which has been operating for hundreds of years. It is now owned and run as a tourist attraction by Eskdale Mill & Heritage Trust, a charity run by local people, who will gain a supplementary income from the power generated to cover some of the mill’s overheads and maintenance costs.
| Location | Boot, Eskdale Valley, Cumbria, England |
| Commissioned | July 2016 |
| Output | 3.5 kW |
| Flow rate | 120 l/s |
| Wheel diameter | 4.0 m |
| Wheel width | 0.8 m |
| Gearbox | Brevini epicyclic |
| Generator | Brook Crompton three-phase, 415V induction motor converted to single-phase 240V |
The power and efficiency is calculated below.
available power: 4,706.0 watt
efficiency: 74.37%
The Langdale Hotel and Spa, English Lake District
This water wheel was also build by Smith Engineering and based on research and development that Smith Engineering had undertaken with Dr Paddy Quinlan of the University of Cumbria on bucket design and efficiency. There is a high degree fo simularity in the look of this water wheel to the one that Kris built.
| Location | Great Langdale, Cumbria, England |
| Commissioned | November 2014 |
| Output | 6 kW |
| Flow rate | 200 l/s |
| Wheel diameter | 4.1 m |
| Wheel width | 1 m |
| Gearbox | Brevini epicyclic 177:1 ratio |
| Generator | Brook Crompton three-phase, 415V induction motor, power rating of 11kW |
H = 4.1*ureg.meter
Q = 200*ureg.liter/(1*ureg.sec)
(rho*g*Q*H).to('watts')
print('available power: {:,.1fP}'.format((rho*g*Q*H).to('watts')))
print('efficiency: {:,.2f}%'.format(((6000*ureg.W)/(rho*g*Q*H).to('watts')).magnitude*100))
print('generator rated power to avaliable power: {:,.2f}'.format(((11000*ureg.W)/(rho*g*Q*H).to('watts')).magnitude))available power: 8,039.4 watt
efficiency: 74.63%
generator rated power to avaliable power: 1.37
Links to other water wheel videos:
Some take aways:
The analysis of the project will consist of looking at the performance of the water wheel based on the information avaliable from the four YouTube videos. In the calculations that follow, the head height is the same as the water wheel diameter.
head height: 2.1 m
Kris use an overall efficieny of 60% in his calculations. I’ve decided to break out the efficiencies of the major parts and then calculate an overall efficiency.
A typical overshot Water wheel has the water channeled to the wheel at the top and slightly beyond the axle. The water collects in the buckets on that side of the wheel, making it heavier than the other “empty” side. The weight turns the wheel and the water flows out into the tail-water when the wheel rotates enough to invert the buckets. The overshot design can achieve 90% efficiency. Nearly all of the energy is gained from the weight of water lowered to the tailrace although a small contribution may be made by the kinetic energy of the water entering the wheel.
The efficiencies I’ll be using in my calculations:
These effencienies have been adjusted to give an overall efficiency in line with what has been acheived in the case studies.
In the YouTube video and the project survey, Kris stated that the veritcal height that was available down stream from the dam would allow for a 2.1 meter diameter water wheel with some room clearace above and below. The flume would need to be about 8 meters long. The flow rate avalailbe ranged from 60 to 120 liters per second (lps or l/s) and that the goal was to generate 1,500 Watts, presummably at 120 lps.
| avaliable vertical height for wheel | 2.1 meters |
| water flow rate | 60 to 120 lps |
| flume length | 8 meters |
| objective generated power out | 1500W at 120 lps |
I’ve decided to include a design marging of 15% in the power estimate calculation to account for unknowns and poor estimates.
The gravitation power of water at various flow rates is plotted below.
step_size = 20
Q = np.arange(60, 180+step_size, step_size)*ureg.liter/(1*ureg.sec)
plt.plot(Q.to('liter per sec').magnitude,(rho*g*Q*H*eta_total*(1-design_margin)).to('watts').magnitude,'-k')
plt.grid()
#plt.ylim((0,10))
plt.ylabel('power , Watts')
plt.xlabel('flow rate, l/s')
plt.title('Gravitational power of water, head height: {:.1fP}, \u03B7: {:.3f}'.format(H,eta_total))
plt.show()This data is dispayed in the table below:
print(‘head height: {:.1fP}, 3B7: {:.3f}, design margin: {:.2f}’.format(H,eta_total,design_margin)) print(‘{:<15s}{:<10s}’.format(‘Flow rate’, ‘power’)) for i in Q: print(‘{:<3.0f~P} {:<,.1f~P}’.format(i.to(‘l/s’),(rhogiHeta_total*(1-design_margin)).to(‘watts’)))
#H = 2.6*ureg.meter
#eta = 0.6
#Q = np.array([60,70,80,90,100,110,116])*ureg.liter/(1*ureg.sec)
print('head height: {:.1fP}, \u03B7: {:.1f}'.format(H,eta))
table_header = ['Flow rate, lps', 'power, W']
table_row = []
for i in Q:
table_row.append([i.to('l/s').magnitude,(rho*g*i*H*eta_total*(1-design_margin)).to('watts').magnitude])
print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f')))head height: 2.1 meter, η: 0.6
Flow rate, lps power, W
---------------- ----------
60 783.8
80 1,045.0
100 1,306.3
120 1,567.5
140 1,828.8
160 2,090.0
180 2,351.3
With in the flow rate range of 60 l/s to 180 l/s,
the estimated power avaliable is 783.8 W to 2351.3 W.
Looks like making 1500 W at 120 lps is feasable.
Kris utilized only a volt meter and relied on the inverter to provide him an indication of the power being generated. For testing, he should have used a resistive load, a volt meter (which he did use) and an amp meter. He could have used the dump load across the three phase recitfier. This would have eliminated any setup issues with the inverter.
In the videos, Kris was using inverter as the electrical load for the generator. I think he should have been using a high power resistive load for his inital tests. Three portable electric heater or his dump load could have been used for testing. Once everything was sorted out, he could then connect to the inverter for additional tests.
To calculate the load resistance for testing, I’m assuming that 1500 Watts is the load he should be using; I’m also assuming the geneator makes 220 volts at the rate power at 500 RPM.
Kris didn’t say too much about the inverter, except that he was able to control the speed of the wheel by changing the mode to constant voltage and setting the value to 100 volts. This casued the genrator to get too hot under full flow conditions. About this time he started to suspect that the rating of the generator was much less than advertised. But the situations is a little confusing. I suspect that the availavle power was much greater than the power indicated on the inverter display, so the difference was being dissipated as heat in the generator, since the generator was being forced to provide a breaking load to the water wheel. This is why using a fixed power resistor as the load would have been much better for inital testing.
current delivered to test load: 6.8 A
resistance of test load: 32.3 Ω
I’m going to assum that the generator’s output voltage is linear with respect to the generator shaft rotational speed (at least over the normal operating RPM range). In the videos, Kris used several generators. The first one appears to have a rated voltage of 220 Volts. Later this generator was swapped out for one with a lower voltage rating of 96 Volts. In the final video, Kris changes the generator to an induction motor.
water_wheel_rotation_frequency = (np.arange(5,16))*ureg.rpm
gear_box = 40
gen_voltage = ((220/500)*water_wheel_rotation_frequency.magnitude*gear_box)*ureg.volt
plt.plot(water_wheel_rotation_frequency.magnitude,gen_voltage.to('volt').magnitude, '-')
plt.grid()
plt.ylabel('generator out put, volts')
plt.xlabel('water wheel RPM')
plt.title('generator output voltage')
plt.show()Later, I’ll look at power flow through the hydo system. Power from gravity on the mass of the water, to the rotational power of the wheel (RPM x torque), to the genrator and finally to the electrical test load. Accounting for losses along the way, the power delivered to the electrical load should be equal to the rotational power of the wheel minus the losses.
The water wheel the Kris designed and fabricated has a diameter of 2.1 meters, 16 buckets, each with a capacity of 48 liters and the wheel width is 0.8 meters. In the calculations that follow, I’m assuming the wheel will have a rotational frequency of between 5 to 15 rotations per minute (rpm). The electrical load on the generator will limit the rotational frequency of the water wheel by resisting the torque delivered to the generator shaft. The electrical load is provided by the inverter. Through out the calculations that follow, I’m assuming that the wheel rotation frequency will be limited by the electrical load placed on the generator by the inverter. If the wheel is making 1000 Watts and delivering this power to the generator shaft, it is assumed that the generator will extract the power at an RPM within the range of 5 to 15 RPM based on the action of the inverter.
There are 16 buckets, each with a capacity of 48 liters. I’ll assum that the buckets will fill to a level of 95% of the bucket volumn. However, Kris stated in his video, that he though the bucket capacity was more like 50 liters because of the side wall of the wheel frame. In all the water wheels that I have observed on various YouTube videos, the buckets don’t fill to 100%.
For a give rpm and fill level, the water wheel can move a fixed amount of water. The water carring capacity is calculated by taking the rotation frequency times the number if buckets times the bucket capacity utilization. The Python pint library keeps track of the units. The number of buckets has the dimention of 16 per circle, so the product of the terms has dimentions that can be converted to liters per second.
The water wheel carring capacity at various flow rates is plotted below.
plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_rotation_frequency*number_of_buckets*bucket_volume*bucket_capacity_utilization).to('liter/sec').magnitude, '-')
plt.grid()
plt.ylabel('water carring capacity, l/s')
plt.xlabel('wheel RPM')
plt.title('water carring capacity, buckets are {:.0f}% full'.format(bucket_capacity_utilization*100))
plt.show()The wheel carring capacity versus wheel RPM is tabulated below.
print(‘{:<15s}{:<10s}’.format(‘wheel rpm’, ‘water carring capacity’)) for i in water_wheel_rotation_frequency: print(‘{:<4.1f~P} {:<,.1f~P}’.format(i.to(‘rpm’),(inumber_of_bucketsbucket_volume*bucket_capacity_utilization).to(‘liter/sec’)))
table_header = ['wheel rpm', 'water carring capacity, lps']
table_row = []
for i in water_wheel_rotation_frequency:
table_row.append([i.to('rpm').magnitude,(i*number_of_buckets*bucket_volume*bucket_capacity_utilization).to('liter/sec').magnitude])
print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f'))) wheel rpm water carring capacity, lps
----------- -----------------------------
5 60.8
6 73.0
7 85.1
8 97.3
9 109.4
10 121.6
11 133.8
12 145.9
13 158.1
14 170.2
15 182.4
At 10 RPM, the wheel can move at most 121 lps. At higher flow rates, the excess water will over flow the buckets and not contribute any additional weight to the bucket.
The force that turns the wheel is provided by gravity and the mass of the water. Only about half of the buchets on one side of the wheel are filled with water and the weight imbalance causes the wheel to turn under the force of gravity.
calculations
moment arm
Torque
units
Let’s assume that half of the buckets have water. Assume 95% bucket capacity utilization.
\(\large{\color {red} {\text{clean up narrative}}}\)
need to convert the above to units of pound force
The pound of force or pound-force (symbol: lbf,[1] sometimes lbf,[2]) is a unit of force used in some systems of measurement, including English Engineering units[a] and the foot–pound–second system.[3]
Pound (force)
The pound of force or pound-force (symbol: lbf,[1] sometimes lbf,[2]) is a unit of force used in some systems of measurement, including English Engineering units[a] and the foot–pound–second system.[3]
Pound-force should not be confused with pound-mass (lb), often simply called “pound”, which is a unit of mass; nor should these be confused with foot-pound (ft⋅lbf), a unit of energy, or pound-foot (lbf⋅ft), a unit of torque.
the meter-kilogram-second gravitational unit of work and energy equal to the work done by a kilogram force acting through a distance of one meter in the direction of the force : about 7.235 foot-pounds
Torque Torque has the dimension of force times distance, symbolically T−2L2M. Although those fundamental dimensions are the same as that for energy or work, official SI literature suggests using the unit newton-metre (N⋅m) and never the joule.[12][13] The unit newton-metre is properly denoted N⋅m.[13]
The traditional imperial and U.S. customary units for torque are the pound foot (lbf-ft), or for small values the pound inch (lbf-in). In the US, torque is most commonly referred to as the foot-pound (denoted as either lb-ft or ft-lb) and the inch-pound (denoted as in-lb).[14][15] Practitioners depend on context and the hyphen in the abbreviation to know that these refer to torque and not to energy or moment of mass (as the symbolism ft-lb would properly imply).
Newton (unit)
The newton (symbol: N) is the unit of force in the International System of Units (SI). It is defined as 1 kg ⋅ m/s 2 { {}^{2}}, the force which gives a mass of 1 kilogram an acceleration of 1 metre per second per second. It is named after Isaac Newton in recognition of his work on classical mechanics, specifically his second law of motion.
A newton is defined as 1 kg ⋅ m/s 2 { {}^{2}} (it is a derived unit which is defined in terms of the SI base units).[1] One newton is, therefore, the force needed to accelerate one kilogram of mass at the rate of one metre per second squared in the direction of the applied force.[2]
The plot above says that at 10 rpm, 116.89 lps of water can be moved with buckets at 90% full.
Make a new plot, don’t assum the buckets are full. For example at 200 lps and 15 rpm, what is the torque?
# do the calculations from 5 to 20 rpm using 100 points
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm
for i in range(len(Q)): # use the same flow rate from above
#water_capacity_per_rotation = number_of_buckets*bucket_volume
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
for j in range(len(water_wheel_rotation_frequency)):
water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
plt.plot(water_wheel_rotation_frequency.magnitude,water_wheel_shaft_torque.to('N m').magnitude,'-',label='{:.1f~P}'.format(Q[i]))
plt.grid()
plt.ylabel('water wheel shaft torque, N m')
plt.xlabel('wheel rpm')
plt.title('new plot')
plt.legend(loc=0)
plt.show()what does this say??
\(\large{\color {red} {\text{clean up narrative}}}\)
gen_shaft_rotation_freq = np.array([125,250,500,1000])ureg.rpm/50 gen_pwr = np.array([0.5,1,2,4])1000*ureg.watts gen_pwr
gen_shaft_rotation_freq
gen_pwr
water_wheel_rotation_frequency
for i in range(len(Q)):
#water_capacity_per_rotation = number_of_buckets*bucket_volume
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
for j in range(len(water_wheel_rotation_frequency)):
water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_shaft_torque*water_wheel_rotation_frequency*eta_waterwheel).to('watts').magnitude,'-',label='{:.1f~P}'.format(Q[i]))
#plt.plot(gen_shaft_rotation_freq.magnitude,gen_pwr.magnitude,'.k',label='{:.1f~P}'.format(Q[i]))
plt.grid()
plt.ylabel('water wheel shaft power, Watts')
plt.xlabel('wheel rpm')
plt.title('new plot')
plt.legend(loc=1)
plt.show()what does this say?
If the controller tries to keep the wheel rpm around 10, then the generator needs to absorb between 1000 and 2200 Watts
at flow rates of 180 lps and above the power levels off at 3kW, so the generator should be sized to higher than 3kW
Print data as a table
R_load
water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
i = 3 #for i in range(len(Q)):
print(‘{:>10s} {:>10s} {:>10s} {:>20s} {:>15s} {:>20s} {:>20s}’.format(‘flow, lps’,‘rpm’,‘torque’,‘avaliable pwr, W’,‘gen voltage’,‘Amps to the load’,‘pwr to the load’))
#water_capacity_per_rotation = number_of_bucketsbucket_volume water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))ureg.kilogramureg.g0ureg.meter
for j in range(len(water_wheel_rotation_frequency)): water_transport_rate = (number_of_bucketsbucket_volumewater_wheel_rotation_frequency[j]).to(‘liter/sec’)
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
available_pwr = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
load_current = load_volts/R_load
load_pwr = R_load*load_current**2
print('{:>10.0f} {:>10.0f} {:>10.0f} {:>20.1f} {:>15.1f} {:>20.1f} {:>20.1f}'.format(Q[i].magnitude,
water_wheel_rotation_frequency[j].magnitude,
water_wheel_shaft_torque[j].to('N m').magnitude,
available_pwr.to('watts').magnitude,
load_volts.magnitude,
load_current.magnitude,
load_pwr.magnitude
))
print(tabulate([[‘Alice’, 24], [‘Bob’, 19]], headers=[‘Name’, ‘Age’]))
water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
i = 3 #for i in range(len(Q)):
#print('{:>10s} {:>10s} {:>10s} {:>20s} {:>15s} {:>20s} {:>20s}'.format('flow, lps','rpm','torque','avaliable pwr, W','gen voltage','Amps to the load','pwr to the load'))
table_header = ['flow','rpm','torque','avaliable pwr','gen voltage','load amps','load pwr']
table_row = []
#water_capacity_per_rotation = number_of_buckets*bucket_volume
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
for j in range(len(water_wheel_rotation_frequency)):
water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
available_pwr = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
load_current = load_volts/R_load
load_pwr = R_load*load_current**2
table_row.append(
[Q[i].magnitude,
water_wheel_rotation_frequency[j].magnitude,
water_wheel_shaft_torque[j].to('N m').magnitude,
available_pwr.to('watts').magnitude,
load_volts.magnitude,
load_current.magnitude,
load_pwr.magnitude])
print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f','.0f',',.1f',',.1f','.1f','.1f',',.1f'))) flow rpm torque avaliable pwr gen voltage load amps load pwr
------ ----- -------- --------------- ------------- ----------- ----------
120 5 2,164.9 1,020.2 88.0 2.7 240.0
120 6 2,164.9 1,224.2 105.6 3.3 345.6
120 7 2,164.9 1,428.3 123.2 3.8 470.4
120 8 2,164.9 1,632.3 140.8 4.4 614.4
120 9 2,164.9 1,836.4 158.4 4.9 777.6
120 10 2,029.6 1,912.9 176.0 5.5 960.0
120 11 1,845.1 1,912.9 193.6 6.0 1,161.6
120 12 1,691.4 1,912.9 211.2 6.5 1,382.4
120 13 1,561.2 1,912.9 228.8 7.1 1,622.4
120 14 1,449.7 1,912.9 246.4 7.6 1,881.6
120 15 1,353.1 1,912.9 264.0 8.2 2,160.0
120 16 1,268.5 1,912.9 281.6 8.7 2,457.6
120 17 1,193.9 1,912.9 299.2 9.3 2,774.4
120 18 1,127.6 1,912.9 316.8 9.8 3,110.4
120 19 1,068.2 1,912.9 334.4 10.4 3,465.6
120 20 1,014.8 1,912.9 352.0 10.9 3,840.0
#water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm
#i = 6 #for i in range(len(Q)):
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
available_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
load_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
for j in range(len(water_wheel_rotation_frequency)):
water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
available_pwr[j] = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
load_current = load_volts/R_load
load_pwr[j] = R_load*load_current**2
plt.plot(water_wheel_rotation_frequency.magnitude,available_pwr.to('watts').magnitude,'-',label='available pwr')
plt.plot(water_wheel_rotation_frequency.magnitude,load_pwr.to('watts').magnitude,'-',label='load pwr')
idx = np.argwhere(np.diff(np.sign(load_pwr.to('watts').magnitude - available_pwr.to('watts').magnitude))).flatten()
plt.plot(water_wheel_rotation_frequency.magnitude[idx],load_pwr.to('watts').magnitude[idx], 'ro')
plt.plot(water_wheel_rotation_frequency.magnitude[idx],available_pwr.to('watts').magnitude[idx], 'kx')
plt.grid()
plt.ylabel('power, Watts')
plt.xlabel('wheel rpm')
plt.title('available power from water wheel, power to R_load = {:.1f~P} @ flow = {:.1f~P}'.format(R_load,Q[i]))
plt.legend(loc=0)
plt.show()
print('the curves intersect at {:.1f} rpm and {:.1f} W'.format(float(water_wheel_rotation_frequency.magnitude[idx]),float(load_pwr.to('watts').magnitude[idx])))the curves intersect at 14.1 rpm and 1906.1 W
Are the graphs below correct? what do they say?
Which to use rotation velocity or Angular velocity??
Rotational frequency, also known as rotational speed or rate of rotation (symbols ν, lowercase Greek nu, and also n), is the frequency of rotation of an object around an axis. Its SI unit is the reciprocal seconds (s−1); other common units of measurement include the hertz (Hz), cycles per second (cps), and revolutions per minute (rpm).
In physics, angular velocity (symbol ω or ω → {}, the lowercase Greek letter omega), also known as angular frequency vector,[1] is a pseudovector representation of how the angular position or orientation of an object changes with time, i.e. how quickly an object rotates (spins or revolves) around an axis of rotation and how fast the axis itself changes direction.
turn = 2 * π * radian = _ = revolution = cycle = circle
[frequency] = 1 / [time]
hertz = 1 / second = Hz
revolutions_per_minute = revolution / minute = rpm
revolutions_per_second = revolution / second = rps
counts_per_second = count / second = cps
The speed of the object traveling the circle is:
\(v=\frac {2\pi r}{T}=\omega r\)
v = tangential speed
r = radius
T = period for one rotation \(\omega\) = angular rate of rotation, also known as angular velocity
\(v=r\omega\)
What is \(\omega\)?
In physics, angular velocity (symbol ω or ω → {}, the lowercase Greek letter omega), also known as angular frequency vector,[1] is a pseudovector representation of how the angular position or orientation of an object changes with time, i.e. how quickly an object rotates (spins or revolves) around an axis of rotation and how fast the axis itself changes direction.
Angular velocity has dimension of angle per unit time; this is analogous to linear velocity, with angle replacing distance, with time in common. The SI unit of angular velocity is radians per second,[2] although degrees per second (°/s) is also common. The radian is a dimensionless quantity, thus the SI units of angular velocity are dimensionally equivalent to reciprocal seconds, s−1, although rad/s is preferable to avoid confusion with rotation velocity in units of hertz (also equivalent to s−1).[3]
Tangential velocity
\(v=\omega r\)
v = tangential speed
r = radius
\(\omega\) = angular rate of rotation, also known as angular velocity
\(v=\frac {2\pi r}{T}\)
v = tangential speed
r = radius
T = period for one rotation
water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_diameter/2*water_wheel_rotation_frequency.to('Hz')).to_base_units().magnitude,'-')
plt.grid()
plt.ylabel('Wheel tangential velocity, m/s')
plt.xlabel('wheel RPM')
plt.title('Wheel tangential velocity')
plt.show()print(‘{:<15s}{:<10s}’.format(‘wheel rpm’, ‘tangential velocity’)) for i in water_wheel_rotation_frequency: print(‘{:<4.1f~P} {:<,.2f~P}’.format(i.to(‘rpm’), (water_wheel_diameter/2*i.to(‘Hz’)).to_base_units()))
table_header = ['wheel rpm', 'tangential velocity, m/s']
table_row = []
for i in water_wheel_rotation_frequency:
table_row.append([i.to('rpm').magnitude,(water_wheel_diameter/2*i.to('Hz')).to_base_units().magnitude])
print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.2f'))) wheel rpm tangential velocity, m/s
----------- --------------------------
5 0.55
6 0.66
7 0.77
8 0.88
9 0.99
10 1.10
11 1.21
12 1.32
13 1.43
14 1.54
15 1.65
16 1.76
17 1.87
18 1.98
19 2.09
20 2.20
Flume water velocity should match the tangential velocity at the flow rate.
Checking on units
turn = 2 * π * radian = _ = revolution = cycle = circle
[frequency] = 1 / [time]
hertz = 1 / second = Hz
revolutions_per_minute = revolution / minute = rpm
revolutions_per_second = revolution / second = rps
counts_per_second = count / second = cps
Rotational frequency units of SI unit Hz, Other units rpm, cps
Tangential speed Tangential speed is the speed of an object undergoing circular motion, i.e., moving along a circular path.[1] A point on the outside edge of a merry-go-round or turntable travels a greater distance in one complete rotation than a point nearer the center. Travelling a greater distance in the same time means a greater speed, and so linear speed is greater on the outer edge of a rotating object than it is closer to the axis. This speed along a circular path is known as tangential speed because the direction of motion is tangent to the circumference of the circle. For circular motion, the terms linear speed and tangential speed are used interchangeably, and both use units of m/s, km/h, and others
\(v=\frac {2\pi r}{T}\)
r = radius
T = the rotation period
Rotational frequency can be obtained dividing angular frequency, ω, by a full turn (2π radians): ν=ω/(2π rad).
There were two generators used in the project
The PM generator had low voltage and high voltage versions
Testing and building a prototype in his shop should have been done. A normal project management process that included design reviews would have required prototypes and lab or shop testing prior to the final design.
Kris complained that the label didn’t match his observations.
First generator is a 2kW PM generator, exact specifications are not clear. Different voltages were used. Kris was unhappy about the perforance of the 1st generator.
Based on my research, the generator is a Rewindagic generator obtained from from AliExpress, which was as far as I can tell is a 2kW, low speed permanent magnet generator, available in various voltages such as 48V, 220V, 400V. The cost in the US is $555.84.
| Model: PMG-2000L | |
|---|---|
| Rated power(w) | 2000W |
| Max power(w) | 2500W |
| Rated voltage(v) | 24v-220v |
| Rated rotated speed(rpm) | 500rpm |
| Start torque(<Nm) | 0.74 Nm |
| Rated torque (<Nm) | 16.4 Nm |
| Working temperature | -40 - 80 centigrade |
Kris should have test this generator on a test stand, then mocked up the generator with the gear box and pulleys. I don’t know what he was expecting the water wheel rotational speed to be when he was doing the design, but 10 RPM at 120 lps seems about right to me. He needed a gear ratio of 10:500 or 1:50, but his inital design was a 1:20. Later he upped the gear ratio to 1:40.
Testing on a gernerator test stand, rather than on site infront of the customer, is always prefered. He would have determine if the Rewindagic generator would meet his needs.
complained about heat, thin wires,
corresponded with the supplier,
determined that many generators advertized on line are probably rate incorrectly
dertermined that the actual capabilites of the generator is likely 500 Watts sustained.
available power to generator: 2,112.4 W
Assuming that the generator will convert avaliable power to electrical energy. Then losses internal to the generator will produce heat.
generator losses as heat: 211.2 W
\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise, get units working}}}\)
See heat transfer text book page 816, example 15-10
Horizontal cylinder
Simplified relation for natural convection heat transfer coefficient for a horizontal cylinder, Table 15-1 [1].
\(h_{conv}=1.32 {\frac {\Delta T}{D}}^{0.25}\)
where:
\(h_{conv}\) = heat transfer coefficient for a horizontal cylinder
\(\Delta T\) = difference in surface temperature and surrounding air \(D\) = diameter of cylinder
Heat transfer
\(Q_{conv}=h_{conv}A \Delta T\)
where:
\(Q_{conv}\) = convective heat transfer \(h_{conv}\) = heat transfer coefficient
\(A\) = area of motor case
\(\Delta T\) = surface temperature with surrounding enviroment
Referene:
1. Yunus A. Cengel, Heat Transfer: A Practical Approach, 2nd edition, McGraw-Hill, 2003
Modeling the surface area of the generator as a cylinder with hemishpere end pieces. The diameter has been increased by 25% to account for radiating fins on the case.
There is heat transfer from the case to the frame through the mounting bracket.
Put formula here with some narrative
\(Q_{rad}=\epsilon A_s \sigma (T_s^4 - T_{surr}^4)\)
where: \(Q_{rad}\) = radiated heat transfer between the surface at temperature \(T_s\) completely surrounded by a much larger surface at temperature \(T_{surr}\)
\(\epsilon\) = emissivity of the surface
\(A_s\) = surface area
\(\sigma\) = Stefan Boltzmann constant
\(T_s\) = surface temperature \(T_{surr}\) = surrounding temperature
\(Q_{cond}=\frac {\Delta T}{R}\)
where:
\(Q_{cond}\) = cinducted heat transfer between mounting feet and frame \(\Delta T\) = surface temperature with surrounding enviroment
\(R\) = thermal resistance of generator base to frame
total_heat_out = Q_conv+Q_rad+Q_cond
print('total heat transfered from the generator body to the enviroment: {:.1f} Watts'.format(total_heat_out))
generator_losses_as_heat = (rho*g*Q*H*eta_waterwheel*eta_gear_box*(1-eta_generator)).to('watt')
print('generator losses as internal heat: {:.1f~P}'.format(generator_losses_as_heat))
print('net generator heat flow: {:.1f} Watts'.format(total_heat_out - generator_losses_as_heat.magnitude))total heat transfered from the generator body to the enviroment: 144.3 Watts
generator losses as internal heat: 211.2 W
net generator heat flow: -66.9 Watts
Since the net heat flow is negative, the generator will heat up.
\(\large{\color {red} {\text{why did the 1st generator get hot?}}}\)
Comments on PM generator
The second generator tried was a 2.2kW, 8 pole, induction generator from Tec Motors. This motor need 750 rpm for make the rated power.
with the gear ratio of 1:40 and a water wheel rpm of 18, the generator shaft RPM is 720.
With the efficiencies and derating applied, I he will not get 1500 W as shown below.
Self excited induction generator (part 1)
Self excited induction generator (part 2)
generated_rated_pwr = 2200ureg.watt(720/750) generator_derating = 0.9
print(‘generator internal losses as heat: {:.1f~P}’.format(generated_rated_pwr(1-eta_generator)generator_derating))
generator losses as heat: 211.2 W
same as above
\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise}}}\)
\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise, get units working}}}\)
total_heat_out = Q_conv+Q_rad+Q_cond
print('total heat transfered from the generator body to the enviroment: {:.1f} Watts'.format(total_heat_out))
generator_losses_as_heat = (rho*g*Q*H*eta_waterwheel*eta_gear_box*(1-eta_generator)).to('watt')
print('generator losses as internal heat: {:.1f~P}'.format(generator_losses_as_heat))
print('net generator heat flow: {:.1f} Watts'.format(total_heat_out - generator_losses_as_heat.magnitude))total heat transfered from the generator body to the enviroment: 266.0 Watts
generator losses as internal heat: 211.2 W
net generator heat flow: 54.7 Watts
The net heat transfer is rate is positive so OK.
In addition to not makeing 1500 W, he needs a new gear box with a ratio of 10:750 or 1:75.
Comments about the induction genertor
\(\large{\color {red} {\text{Replot the power curve intercestion for the induction generator, RPM is different}}}\)
step_size = 20
Q = np.arange(60, 180+step_size, step_size)*ureg.liter/(1*ureg.sec)
#water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm
i = 0 #for i in range(len(Q)):
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
available_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
load_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
for j in range(len(water_wheel_rotation_frequency)):
water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')
bucket_capacity_utilization = Q[i]/water_transport_rate
# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
bucket_capacity_utilization = 1
water_transport_rate = Q[i]
weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization
torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()
available_pwr[j] = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
load_volts = (220/750)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
load_current = load_volts/R_load
load_pwr[j] = R_load*load_current**2
plt.plot(water_wheel_rotation_frequency.magnitude,available_pwr.to('watts').magnitude,'-',label='available pwr')
plt.plot(water_wheel_rotation_frequency.magnitude,load_pwr.to('watts').magnitude,'-',label='load pwr')
idx = np.argwhere(np.diff(np.sign(load_pwr.to('watts').magnitude - available_pwr.to('watts').magnitude))).flatten()
plt.plot(water_wheel_rotation_frequency.magnitude[idx],load_pwr.to('watts').magnitude[idx], 'ro')
plt.plot(water_wheel_rotation_frequency.magnitude[idx],available_pwr.to('watts').magnitude[idx], 'kx')
plt.grid()
plt.ylabel('power, Watts')
plt.xlabel('wheel rpm')
plt.title('available power from water wheel, power to R_load = {:.1f~P} @ flow = {:.1f~P}'.format(R_load,Q[i]))
plt.legend(loc=0)
plt.show()
print('the curves intersect at {:.1f} rpm and {:.1f} W'.format(float(water_wheel_rotation_frequency.magnitude[idx]),float(load_pwr.to('watts').magnitude[idx])))the curves intersect at 14.8 rpm and 940.7 W
The flow rate need to be lowered for the cureves to intersect and to keep the wheel RPM reasonable.
The gear box ratio need to be
The flume carries water from the dam to the top of the waterwheel. By examining the videos, I made some estimates for the flume dimensions.
The width of the flume was about the same width of the waterwheel, which makes sense, since you want a nice flow of water into the buckets.
The side walls of the flume looked like 2 by 6 inch boards. The depth of the water in the channel looks like a maximum of 5 inches of flow. Also, the buckets need to handle what ever the flow rate is. Need to look at the RPM.
I can use the Manning equation for open channel flow to calculate the flow rate in the flume. Mannings equation is an empirical equation that applies to uniform flow in open channels and is a function of the channel velocity, flow area and channel slope.
\(V = \frac {s^{1/2} \times R^{2/3}} {n}\)
where:
V - water velocity
n - Manning’s roughness coefficient; unplaned wood = 0.013, wood sides and smooth sheet metal bottom
R - The channel’s hydraulic radius, calculated by dividing the water flow’s cross-sectional area A by its wetted perimeter P
s - Slope of the channel’s bottom surface
Examining Manning’s equation, we can see that the area and slope are directly proportional to the water flow rate, which means an increase in area and slope would increase the water flow rate. On the other hand, the roughness coefficient and the wetted perimeter are inversely proportional to the water flow rate, meaning that increasing their values would decrease the water flow rate.
The slope of the flume was not apparent in any of the videos, so I’m using a value of 0.01.
\(\large{\color {red} {\text{get some screen shots of the flume}}}\)
This does not agree with the text, which states: > Because this has to be quite long (approximately 8 meters) there needs to be a downward slope in order to keep the water flowing. I have made this slope 1 degree and it equates to a 300mm level change.
The math works out to about 2 degrees.
So which is it, 1 degree or 300mm drop?
flume_width = 800*ureg.mm
water_depth = 70*ureg.mm # estimate
# convert to base units
flume_width.ito('meter')
water_depth.ito('meter')
water_cross_section_area = water_depth*flume_width
print('water_cross_section_area = {:.4f~P}'.format(water_cross_section_area))
wetted_perimeter = 2*water_depth+flume_width
print('wetted_perimeter = {:.4f~P}'.format(wetted_perimeter))
hydraulic_radius = water_cross_section_area/wetted_perimeter
print('hydraulic_radius = {:.4f~P}'.format(hydraulic_radius))
roughness_coefficient = 0.013 # Wood - unplaned
slope = flume_slope #0.0025
print('slope = {:.4f}'.format(slope))
# need to use magnitude of quantity when using fractional exponents
water_flume_velocity = (((hydraulic_radius.magnitude)**(2/3)*slope**(1/2))/roughness_coefficient)*ureg.meter/ureg.sec
print('water_flume_velocity = {:.4f~P}'.format(water_flume_velocity))
volumetric_flow_rate = water_flume_velocity*water_cross_section_area
print('volumetric_flow_rate = {:.6f~P}'.format(volumetric_flow_rate))
print('volumetric_flow_rate = {:.2f~P}'.format(volumetric_flow_rate.to('liter/sec')))water_cross_section_area = 0.0560 m²
wetted_perimeter = 0.9400 m
hydraulic_radius = 0.0596 m
slope = 0.0375
water_flume_velocity = 2.2722 m/s
volumetric_flow_rate = 0.127243 m³/s
volumetric_flow_rate = 127.24 l/s
Think about working the problem in reverse: the water wheel is rotating at 10 rpm, which is about 115 lps of flow rate consumed by the water wheel.
The flume water velocity should match the wheel tangential velocity at flow rate of 115 lps.
\(\large{\color {red} {\text{Find a spot in the videos where the depth in the flume can be estimated and where he shows the power}}}\)
does he also say bucket fill level?
spillway baffles
In this study, a two-dimensional physical model was used to evaluate the effectiveness of adding baffles and sills at step edges or of shifting them from step edges of a 1V:1H sloping, short, sharp- or round-crested stepped spillway with an ogee inlet. A comparison between different configurations of baffles and sills was carried out with respect to the energy dissipation and the flow characteristics. The baffle-shifted round-crested spillway gives the smallest discharge required for the onset of a skimming flow among all other configurations. The baffle-edged chute dissipates more energy than the sill-edged spillway. Shifting baffles or sills from the sharp edges decreases the energy dissipation. Shifting baffles or sills from the round-crested spillway increases the energy dissipation in the range of the discharges studied. Empirical equations for energy dissipation are introduced for practical application of spillways of comparable similar conditions.
Four general aspects of spillways are worth noting. First, the uncontrolled discharge of surplus water past the dam should be automatic and not dependent upon human control. Second, the spillway intake should be wide enough so that the largest floods can pass without increasing the water level in the reservoir enough to cause a nuisance to upstream property owners. Third, the rate of floodwater discharge should not increase much above that experienced before the construction of the dam. An increase in discharge can cause flood problems downstream, but a dam usually reduces the peak discharge rate because of the lag effect caused by a flood passing through the reservoir. Fourth, floodwater discharged over the height of a dam can be destructive to the dam structure itself and to the riverbed unless its energy is controlled and dissipated in harmless turbulence.
HYDRAULIC INVESTIGATIONS 1T ~~ 4) AND LABORATORY SERVICES OFFICIAL FILE COPY A BAFFLED APRON AS A SPILLWAY ENERGY DISSIPATOR
flume_width = 800*ureg.mm
water_depth = 200*ureg.mm
# convert to base units
flume_width.ito('meter')
water_depth.ito('meter')
water_cross_section_area = water_depth*flume_width
print('water_cross_section_area = {:.4f~P}'.format(water_cross_section_area))
wetted_perimeter = 2*water_depth+flume_width
print('wetted_perimeter = {:.4f~P}'.format(wetted_perimeter))
hydraulic_radius = water_cross_section_area/wetted_perimeter
print('hydraulic_radius = {:.4f~P}'.format(hydraulic_radius))
roughness_coefficient = 0.013 # Wood - unplaned
slope = 0.0025
print('slope = {:.4f}'.format(slope))
# need to use magnitude of quantity when using fractional exponents
water_flume_velocity = (((hydraulic_radius.magnitude)**(2/3)*slope**(1/2))/roughness_coefficient)*ureg.meter/ureg.sec
print('water_flume_velocity = {:.4f~P}'.format(water_flume_velocity))
volumetric_flow_rate = water_flume_velocity*water_cross_section_area
print('volumetric_flow_rate = {:.6f~P}'.format(volumetric_flow_rate))
print('volumetric_flow_rate = {:.2f~P}'.format(volumetric_flow_rate.to('liter/sec')))water_cross_section_area = 0.1600 m²
wetted_perimeter = 1.2000 m
hydraulic_radius = 0.1333 m
slope = 0.0025
water_flume_velocity = 1.0038 m/s
volumetric_flow_rate = 0.160610 m³/s
volumetric_flow_rate = 160.61 l/s
This project was done in the UK, but now I’m switching to my local cost of electricity and currency in USD. Assume that the house or property uses 400 Watts average.
I pay 32 cents per kWh if I stay below 11.4 kWh per day
includes generating cost, delivery costs and goverment fees and taxes. I could pay more if I wanted my power classified as ‘green power’.
The electrical rate is $0.35 per kWh. The daily and yearily electrical costs are as follows:
house_pwr_usage = 400*ureg.watt
meter_rate = 0.32/(1000*ureg.Wh)
print('house daily energy usage: {:,.0f~P}'.format((24*ureg.hr*house_pwr_usage).to('Wh')))
print('house daily energy usage cost: ${:.2f}'.format((24*ureg.hr*house_pwr_usage*meter_rate).to_base_units().magnitude))
house_yearly_energy_usage_cost = 365*24*ureg.hr*house_pwr_usage*meter_rate
print('house yearly energy usage cost: ${:,.2f}'.format(house_yearly_energy_usage_cost.to_base_units().magnitude))house daily energy usage: 9,600 Wh
house daily energy usage cost: $3.07
house yearly energy usage cost: $1,121.28
Since the water wheel is generating more power than needed, the cost saved per year is equal to the cost of electrical energy consumed.
cost saved per year: $1,121.28
The net energy used per day is the generated energy per day minus the daily energy usage.
net energy per day: 26,400 W·h
As an example, Southern California Edison (SCE) has a Net Surplus Compensation Rate (NSCR) that compensates Net Energy Metering (NEM) customers for electricity they produce in excess of their on-site load over the course of a 12-month period, referred to as the “Relevant Period.” NEM customers who produce excess power over their Relevant Period are known as Net Surplus Generators. NSCR is calculated using a market-based mechanism derived from an hourly day-ahead electricity market price known as the Default Load Aggregation Point (DLAP) price. Southern California Edison’s DLAP price reflects the costs SCE avoids in procuring power during the time period Net Surplus Generators are likely to produce excess power with their solar or wind generating facilities.
| For Relevant Period Ending | NSCR Energy ($/kWh) |
|---|---|
| January 2024 | 0.04696 |
| December 2023 | 0.05881 |
| November 2023 | 0.06030 |
| October 2023 | 0.06268 |
| September 2023 | 0.06818 |
| August 2023 | 0.07009 |
| July 2023 | 0.07224 |
| June 2023 | 0.07512 |
| May 2023 | 0.07712 |
| April 2023 | 0.07778 |
| March 2023 | 0.07494 |
| February 2023 | 0.07276 |
| January 2023 | 0.06212 |
The average NSCR for the trailing 12 months is calculated below
the average net meter rate for the trailing 12 months: 0.068 per kWh
net_meter_rate = avg_net_meter_rate/((1000*ureg.Wh)) # amount per kWh
#net_meter_rate = 0.15/((1000*ureg.Wh)) # amount per kWh
print('net meter rate: ${:.2f} per kWh'.format(net_meter_rate.magnitude*1000))
print('Net meter credit: ${:,.2f} per day'.format((net_energy_day*net_meter_rate).to_base_units().magnitude))
net_meter_credit_yr = (365*net_energy_day*net_meter_rate).to_base_units()
print('Net meter credit: ${:,.2f} per year'.format(net_meter_credit_yr.magnitude))net meter rate: $0.07 per kWh
Net meter credit: $1.79 per day
Net meter credit: $651.62 per year
The cost of construction for the dam, spillway and water wheel is estimated to be $20,000. But this is just a guess since Kris didn’t share any financial innformation.
The maintence cost per year is estimated to be $200.
The project life is estimated to be 15 years. This is the time frame that the internal rate of return will be calculated for. The internal rate of return is a method of quantifying the merits of a project or investment opportunity. The calculation is termed internal because it depends only on the cash flows of the investment being analyzed and excludes external factors, such as returns available elsewhere, the risk-free rate, inflation, the cost of capital, or financial risk.
construction_cost = 20000 # who knows?
maintenance_cost = 200 # per year
#net_meter_credit_per_year = (365*generator_energy*net_meter_rate).to_base_units().magnitude
project_life = 15 # years
cash_flow_each_year = np.ones(project_life)*(saved_cost_yr+net_meter_credit_yr-maintenance_cost).magnitude
# include construction cost in 1st year
cash_flow_each_year[0] = cash_flow_each_year[0]-construction_cost
#cash_flow_each_yeardef irr(values, guess=None, tol=1e-12, maxiter=100):
"""
Return the Internal Rate of Return (IRR).
This is the "average" periodically compounded rate of return
that gives a net present value of 0.0; for a more complete explanation,
see Notes below.
:class:`decimal.Decimal` type is not supported.
Parameters
----------
values : array_like, shape(N,)
Input cash flows per time period. By convention, net "deposits"
are negative and net "withdrawals" are positive. Thus, for
example, at least the first element of `values`, which represents
the initial investment, will typically be negative.
guess : float, optional
Initial guess of the IRR for the iterative solver. If no guess is
given an heuristic is used to estimate the guess through the ratio of
positive to negative cash lows
tol : float, optional
Required tolerance to accept solution. Default is 1e-12.
maxiter : int, optional
Maximum iterations to perform in finding a solution. Default is 100.
Returns
-------
out : float
Internal Rate of Return for periodic input values.
"""
values = np.atleast_1d(values)
if values.ndim != 1:
raise ValueError("Cashflows must be a rank-1 array")
# If all values are of the same sign no solution exists
# we don't perform any further calculations and exit early
same_sign = np.all(values > 0) if values[0] > 0 else np.all(values < 0)
if same_sign:
return np.nan
# If no value is passed for `guess`, then make a heuristic estimate
if guess is None:
positive_cashflow = values > 0
inflow = values.sum(where=positive_cashflow)
outflow = -values.sum(where=~positive_cashflow)
guess = inflow / outflow - 1
npv_ = np.polynomial.Polynomial(values[::-1])
d_npv = npv_.deriv()
g = 1 + guess
for _ in range(maxiter):
delta = npv_(g) / d_npv(g)
if abs(delta) < tol:
return g - 1
g -= delta
return np.nanThe internal rate of return is calculated and shown below.
internal rate of return: 2.5%
This rate of return is very small and indicates that the funds spent on the construction might be better used elsewhere. The low IRR is primarily driven by two factors, the low net meter rate and the average Watts used. The low IRR also indicates that this hydro system probably should not be grid tied and only makes sense for true off grid situations.
If the house uses uses all the hydro power, then the IRR is favorable.